using System;
using System.Collections.Generic;
using ns26;
using ns27;
using Triton.Game.Mono;

namespace Triton.Game.Mapping
{
	[Attribute38("GameEntity")]
	public class GameEntity : Entity
	{
		[Attribute38("GameEntity.EndGameScreenContext")]
		public class EndGameScreenContext : MonoClass
		{
			public EndGameScreen m_screen => method_3<EndGameScreen>("m_screen");

			public Spell m_enemyBlowUpSpell => method_3<Spell>("m_enemyBlowUpSpell");

			public Spell m_friendlyBlowUpSpell => method_3<Spell>("m_friendlyBlowUpSpell");

			public EndGameScreenContext(IntPtr address, string className)
				: base(address, className)
			{
			}

			public EndGameScreenContext(IntPtr address)
				: this(address, "EndGameScreenContext")
			{
			}
		}

		public int m_preloadsNeeded => method_2<int>("m_preloadsNeeded");

		public int m_realTimeTurn => method_2<int>("m_realTimeTurn");

		public GameEntity(IntPtr address, string className)
			: base(address, className)
		{
		}

		public GameEntity(IntPtr address)
			: this(address, "GameEntity")
		{
		}

		public void FadeOutHeroActor(Actor actorToFade)
		{
			method_8("FadeOutHeroActor", actorToFade);
		}

		public void FadeOutActor(Actor actorToFade)
		{
			method_8("FadeOutActor", actorToFade);
		}

		public void FadeInHeroActor(Actor actorToFade)
		{
			method_9("FadeInHeroActor", new Class276.Enum20[1] { Class276.Enum20.Class }, actorToFade);
		}

		public void FadeInHeroActor(Actor actorToFade, float lightBlendAmount)
		{
			method_9("FadeInHeroActor", new Class276.Enum20[2]
			{
				Class276.Enum20.Class,
				Class276.Enum20.R4
			}, actorToFade, lightBlendAmount);
		}

		public void FadeInActor(Actor actorToFade)
		{
			method_9("FadeInActor", new Class276.Enum20[1] { Class276.Enum20.Class }, actorToFade);
		}

		public void FadeInActor(Actor actorToFade, float lightBlendAmount)
		{
			method_9("FadeInActor", new Class276.Enum20[2]
			{
				Class276.Enum20.Class,
				Class276.Enum20.R4
			}, actorToFade, lightBlendAmount);
		}

		public void PreloadSound(string soundPath)
		{
			method_8("PreloadSound", soundPath);
		}

		public void OnSoundLoaded(AssetReference assetRef, GameObject go, object callbackData)
		{
			method_8("OnSoundLoaded", assetRef, go, callbackData);
		}

		public void RemovePreloadedSound(string soundPath)
		{
			method_8("RemovePreloadedSound", soundPath);
		}

		public bool CheckPreloadedSound(string soundPath)
		{
			return method_11<bool>("CheckPreloadedSound", new object[1] { soundPath });
		}

		public bool IsPreloadingAssets()
		{
			return method_11<bool>("IsPreloadingAssets", Array.Empty<object>());
		}

		public new bool HasValidDisplayName()
		{
			return method_11<bool>("HasValidDisplayName", Array.Empty<object>());
		}

		public new string GetName()
		{
			return method_13("GetName");
		}

		public new string GetDebugName()
		{
			return method_13("GetDebugName");
		}

		public new void OnTagsChanged(TagDeltaList changeList)
		{
			method_8("OnTagsChanged", changeList);
		}

		public new void OnRealTimeTagChanged(Network.HistTagChange change)
		{
			method_8("OnRealTimeTagChanged", change);
		}

		public new void OnTagChanged(TagDelta change)
		{
			method_8("OnTagChanged", change);
		}

		public void SetRealTimeTurn(int turn)
		{
			method_8("SetRealTimeTurn", turn);
		}

		public bool IsCurrentTurnRealTime()
		{
			return method_11<bool>("IsCurrentTurnRealTime", Array.Empty<object>());
		}

		public void PreloadAssets()
		{
			method_8("PreloadAssets");
		}

		public void NotifyOfStartOfTurnEventsFinished()
		{
			method_8("NotifyOfStartOfTurnEventsFinished");
		}

		public bool NotifyOfEndTurnButtonPushed()
		{
			return method_11<bool>("NotifyOfEndTurnButtonPushed", Array.Empty<object>());
		}

		public bool NotifyOfBattlefieldCardClicked(Entity clickedEntity, bool wasInTargetMode)
		{
			return method_11<bool>("NotifyOfBattlefieldCardClicked", new object[2] { clickedEntity, wasInTargetMode });
		}

		public void NotifyOfCardMousedOver(Entity mousedOverEntity)
		{
			method_8("NotifyOfCardMousedOver", mousedOverEntity);
		}

		public void NotifyOfCardMousedOff(Entity mousedOffEntity)
		{
			method_8("NotifyOfCardMousedOff", mousedOffEntity);
		}

		public bool NotifyOfCardTooltipDisplayShow(Card card)
		{
			return method_11<bool>("NotifyOfCardTooltipDisplayShow", new object[1] { card });
		}

		public void NotifyOfCardTooltipDisplayHide(Card card)
		{
			method_8("NotifyOfCardTooltipDisplayHide", card);
		}

		public void NotifyOfCoinFlipResult()
		{
			method_8("NotifyOfCoinFlipResult");
		}

		public List<string> NotifyOfKeywordHelpPanelDisplay(Entity entity)
		{
			return method_14<Class249>("NotifyOfKeywordHelpPanelDisplay", new object[1] { entity })?.method_25();
		}

		public void NotifyOfCardGrabbed(Entity entity)
		{
			method_8("NotifyOfCardGrabbed", entity);
		}

		public void NotifyOfCardDropped(Entity entity)
		{
			method_8("NotifyOfCardDropped", entity);
		}

		public void NotifyOfTargetModeCancelled()
		{
			method_8("NotifyOfTargetModeCancelled");
		}

		public void NotifyOfHelpPanelDisplay(int numPanels)
		{
			method_8("NotifyOfHelpPanelDisplay", numPanels);
		}

		public void NotifyOfDebugCommand(int command)
		{
			method_8("NotifyOfDebugCommand", command);
		}

		public void NotifyOfManaCrystalSpawned()
		{
			method_8("NotifyOfManaCrystalSpawned");
		}

		public void NotifyOfEnemyManaCrystalSpawned()
		{
			method_8("NotifyOfEnemyManaCrystalSpawned");
		}

		public void NotifyOfTooltipZoneMouseOver(TooltipZone tooltip)
		{
			method_8("NotifyOfTooltipZoneMouseOver", tooltip);
		}

		public void NotifyOfHistoryTokenMousedOver(GameObject mousedOverTile)
		{
			method_8("NotifyOfHistoryTokenMousedOver", mousedOverTile);
		}

		public void NotifyOfHistoryTokenMousedOut()
		{
			method_8("NotifyOfHistoryTokenMousedOut");
		}

		public void NotifyOfCustomIntroFinished()
		{
			method_8("NotifyOfCustomIntroFinished");
		}

		public void NotifyOfGameOver(TAG_PLAYSTATE playState)
		{
			method_8("NotifyOfGameOver", playState);
		}

		public void NotifyOfRealTimeTagChange(Entity entity, Network.HistTagChange tagChange)
		{
			method_8("NotifyOfRealTimeTagChange", entity, tagChange);
		}

		public bool ShouldPlayHeroBlowUpSpells(TAG_PLAYSTATE playState)
		{
			return method_11<bool>("ShouldPlayHeroBlowUpSpells", new object[1] { playState });
		}

		public string GetVictoryScreenBannerText()
		{
			return method_13("GetVictoryScreenBannerText");
		}

		public string GetDefeatScreenBannerText()
		{
			return method_13("GetDefeatScreenBannerText");
		}

		public void NotifyOfHeroesFinishedAnimatingInMulligan()
		{
			method_8("NotifyOfHeroesFinishedAnimatingInMulligan");
		}

		public bool NotifyOfTooltipDisplay(TooltipZone tooltip)
		{
			return method_11<bool>("NotifyOfTooltipDisplay", new object[1] { tooltip });
		}

		public void NotifyOfMulliganInitialized()
		{
			method_8("NotifyOfMulliganInitialized");
		}

		public void NotifyOfMulliganEnded()
		{
			method_8("NotifyOfMulliganEnded");
		}

		public void EmoteHandlerDoneLoadingCallback(AssetReference assetRef, GameObject go, object callbackData)
		{
			method_8("EmoteHandlerDoneLoadingCallback", assetRef, go, callbackData);
		}

		public void EnemyEmoteHandlerDoneLoadingCallback(AssetReference assetRef, GameObject go, object callbackData)
		{
			method_8("EnemyEmoteHandlerDoneLoadingCallback", assetRef, go, callbackData);
		}

		public void NotifyOfGamePackOpened()
		{
			method_8("NotifyOfGamePackOpened");
		}

		public void NotifyOfDefeatCoinAnimation()
		{
			method_8("NotifyOfDefeatCoinAnimation");
		}

		public void SendCustomEvent(int eventID)
		{
			method_8("SendCustomEvent", eventID);
		}

		public string GetTurnStartReminderText()
		{
			return method_13("GetTurnStartReminderText");
		}

		public bool ShouldDoAlternateMulliganIntro()
		{
			return method_11<bool>("ShouldDoAlternateMulliganIntro", Array.Empty<object>());
		}

		public bool DoAlternateMulliganIntro()
		{
			return method_11<bool>("DoAlternateMulliganIntro", Array.Empty<object>());
		}

		public float GetAdditionalTimeToWaitForSpells()
		{
			return method_11<float>("GetAdditionalTimeToWaitForSpells", Array.Empty<object>());
		}

		public bool IsKeywordHelpDelayOverridden()
		{
			return method_11<bool>("IsKeywordHelpDelayOverridden", Array.Empty<object>());
		}

		public bool IsMouseOverDelayOverriden()
		{
			return method_11<bool>("IsMouseOverDelayOverriden", Array.Empty<object>());
		}

		public bool AreTooltipsDisabled()
		{
			return method_11<bool>("AreTooltipsDisabled", Array.Empty<object>());
		}

		public bool ShouldShowBigCard()
		{
			return method_11<bool>("ShouldShowBigCard", Array.Empty<object>());
		}

		public bool ShouldShowCrazyKeywordTooltip()
		{
			return method_11<bool>("ShouldShowCrazyKeywordTooltip", Array.Empty<object>());
		}

		public bool ShouldShowHeroTooltips()
		{
			return method_11<bool>("ShouldShowHeroTooltips", Array.Empty<object>());
		}

		public bool ShouldDoOpeningTaunts()
		{
			return method_11<bool>("ShouldDoOpeningTaunts", Array.Empty<object>());
		}

		public bool ShouldHandleCoin()
		{
			return method_11<bool>("ShouldHandleCoin", Array.Empty<object>());
		}

		public List<RewardData> GetCustomRewards()
		{
			return method_14<Class271<RewardData>>("GetCustomRewards", Array.Empty<object>())?.method_25();
		}

		public void HandleRealTimeMissionEvent(int missionEvent)
		{
			method_8("HandleRealTimeMissionEvent", missionEvent);
		}

		public void OnPlayThinkEmote()
		{
			method_8("OnPlayThinkEmote");
		}

		public void OnEmotePlayed(Card card, EmoteType emoteType, CardSoundSpell emoteSpell)
		{
			method_8("OnEmotePlayed", card, emoteType, emoteSpell);
		}

		public void NotifyOfOpponentWillPlayCard(string cardId)
		{
			method_8("NotifyOfOpponentWillPlayCard", cardId);
		}

		public void NotifyOfOpponentPlayedCard(Entity entity)
		{
			method_8("NotifyOfOpponentPlayedCard", entity);
		}

		public void NotifyOfFriendlyPlayedCard(Entity entity)
		{
			method_8("NotifyOfFriendlyPlayedCard", entity);
		}

		public string UpdateCardText(Card card, Actor bigCardActor, string text)
		{
			return method_13("UpdateCardText", card, bigCardActor, text);
		}

		public bool ShouldUseSecretClassNames()
		{
			return method_11<bool>("ShouldUseSecretClassNames", Array.Empty<object>());
		}

		public void StartMulliganSoundtrakcs(bool soft)
		{
			method_8("StartMulliganSoundtrakcs", soft);
		}

		public void StartGameplaySoundtracks()
		{
			method_8("StartGameplaySoundtracks");
		}

		public string GetAlternatePlayerName()
		{
			return method_13("GetAlternatePlayerName");
		}

		public void OnCustomIntroCancelled(Card friendlyHero, Card enemyHero, HeroLabel friendlyHeroLabel, HeroLabel enemyHeroLabel, GameStartVsLetters versusText)
		{
			method_8("OnCustomIntroCancelled", friendlyHero, enemyHero, friendlyHeroLabel, enemyHeroLabel, versusText);
		}

		public bool IsEnemySpeaking()
		{
			return method_11<bool>("IsEnemySpeaking", Array.Empty<object>());
		}

		public bool ShouldDelayCardSoundSpells()
		{
			return method_11<bool>("ShouldDelayCardSoundSpells", Array.Empty<object>());
		}

		public bool ShouldAllowCardGrab(Entity entity)
		{
			return method_11<bool>("ShouldAllowCardGrab", new object[1] { entity });
		}

		public string CustomChoiceBannerText()
		{
			return method_13("CustomChoiceBannerText");
		}

		public Spell BlowUpHero(Card card, SpellType spellType)
		{
			return method_14<Spell>("BlowUpHero", new object[2] { card, spellType });
		}

		public void ShowEndGameScreen(TAG_PLAYSTATE playState, Spell enemyBlowUpSpell, Spell friendlyBlowUpSpell)
		{
			method_8("ShowEndGameScreen", playState, enemyBlowUpSpell, friendlyBlowUpSpell);
		}

		public string GetVictoryScreenPrefabPath()
		{
			return method_13("GetVictoryScreenPrefabPath");
		}

		public string GetDefeatScreenPrefabPath()
		{
			return method_13("GetDefeatScreenPrefabPath");
		}

		public string GetVictoryAudioAsset()
		{
			return method_13("GetVictoryAudioAsset");
		}

		public string GetDefeatAudioAsset()
		{
			return method_13("GetDefeatAudioAsset");
		}

		public string GetNameBannerSubtextOverride(Player.Side playerSide)
		{
			return method_13("GetNameBannerSubtextOverride", playerSide);
		}

		public void OnBlowUpSpellFinished(Spell spell, object userData)
		{
			method_8("OnBlowUpSpellFinished", spell, userData);
		}

		public void ShowEndGameScreenAfterEffects(EndGameScreenContext context)
		{
			method_8("ShowEndGameScreenAfterEffects", context);
		}

		public bool AreBlowUpSpellsFinished(EndGameScreenContext context)
		{
			return method_11<bool>("AreBlowUpSpellsFinished", new object[1] { context });
		}
	}
}
